home *** CD-ROM | disk | FTP | other *** search
/ PC World Interactive 7 / PC World Interactive 7.iso / program / cprog.EXE / VIEWFIL.C < prev    next >
Encoding:
C/C++ Source or Header  |  1995-10-02  |  8.8 KB  |  448 lines
  1. #include <stdio.h>
  2. #include <fcntl.h>
  3. #include <sys\types.h>
  4. #include <sys\stat.h>
  5. #include <io.h>
  6. #include <share.h>
  7. #include <stdlib.h>
  8. #include <string.h>
  9. #include <dos.h>
  10. #include <share.h>
  11. #include <conio.h>
  12. #include <limits.h>
  13. #include <direct.h>
  14. #include "view.h"
  15.  
  16. /*
  17.   VIEWFILE access routines
  18. */
  19.  
  20. UINT view_getc_bwd( VIEWFILE *vf )
  21. {
  22.    int err;
  23.    UINT ret;
  24.    
  25. #if VIEW_HAS_MEMORY
  26.    if (vf->fh == VIEW_MEM_HDL)
  27.      {
  28.      vf->pos--;
  29.      return(memory[vf->pos]);
  30.      }
  31.    else
  32.      {
  33. #endif
  34.      if (view_tell(vf))
  35.        {
  36.        if (vf->idx == 0)
  37.          {
  38.          view_seek(vf,(-1L),SEEK_CUR);
  39.          ret = vf->buf[vf->idx];
  40.          }
  41.        else
  42.          {
  43.          vf->idx --;
  44.          ret = vf->buf[vf->idx];
  45.          }
  46.  
  47.        return(ret);  
  48.        }
  49.      else
  50.        return(VIEW_EOF);
  51. #if VIEW_HAS_MEMORY
  52.      }
  53. #endif
  54. }
  55.  
  56. UINT view_getc_fwd( VIEWFILE *vf )
  57. {
  58.    UINT ret;
  59.  
  60. #if VIEW_HAS_MEMORY
  61.    if (vf->fh == VIEW_MEM_HDL)
  62.      {
  63.      ret = memory[vf->pos];
  64.      vf->pos ++;
  65.      return(ret);
  66.      }
  67.    else
  68.      {
  69. #endif
  70.      if (vf->idx >= vf->len)
  71.        {
  72.        view_seek(vf,(vf->pos+vf->idx),SEEK_SET);
  73.        if (vf->idx >= vf->len) return(VIEW_EOF);
  74.        }
  75.        
  76.      ret = vf->buf[vf->idx];
  77.      vf->idx ++;
  78.      return(ret);  
  79. #if VIEW_HAS_MEMORY
  80.      }
  81. #endif
  82. }
  83.  
  84.  
  85. #if VIEW_HAS_RAW
  86. UINT view_getl_raw( VIEWFILE *vf, UCHAR *line, int dir )
  87. {
  88.     int          num_normal;
  89.     int          num_input;
  90.     int          num_output;
  91.     int          num_fixup;
  92.     UINT ret;
  93.     int          jdx;
  94.     UCHAR         *offset;
  95.  
  96.     if (vf->lmode == VIEW_BIN_MODE) 
  97.       {
  98.       num_fixup = 11;
  99.       num_input   = VIEW_MAX_BINMODE;
  100.       num_output  = 11+VIEW_MAX_BINMODE;
  101.       }
  102.     else if (vf->lmode == VIEW_HEX_MODE) 
  103.       {
  104.       num_fixup = 60;
  105.       num_input   = VIEW_MAX_HEXMODE;
  106.       num_output  = 11+(num_input*3)+1+num_input;
  107.       }
  108.     else
  109.       return(VIEW_EOF);
  110.  
  111.     for( jdx = 0; jdx < num_output; jdx ++)
  112.       line[jdx] = ' ';
  113.     line[jdx] = '\0';
  114.  
  115.     for (ret = num_normal = 0; num_normal < num_input && ret != VIEW_EOF; num_normal ++ )  
  116.       {  
  117.       if (dir)  
  118.         {  
  119.         ret = view_getc_fwd(vf);  
  120.  
  121.         if (ret != VIEW_EOF)  
  122.           {  
  123.           if (!num_normal)  
  124.             {  
  125. #if VIEW_HAS_MEMORY
  126.             if (vf->fh == VIEW_MEM_HDL)
  127.               offset = view_ultoa((ULONG)(memory+(view_tell(vf)-1L)),16,8,'0');  
  128.             else
  129. #endif
  130.               offset = view_ultoa((view_tell(vf)-1L),10,1,'0');  
  131.  
  132.             for (jdx = 0; jdx < 11 ; jdx ++)  
  133.               if (*offset) line[jdx] = *(offset++);  
  134.             }  
  135.  
  136.           if (vf->lmode == VIEW_HEX_MODE)  
  137.             {  
  138.             line[11+num_normal*3]     = hexdigits[ret/16];  
  139.             line[11+num_normal*3+1]   = hexdigits[ret%16];  
  140.             }  
  141.  
  142.           if (ret) line[num_fixup+num_normal]   = ret;  
  143.           }  
  144.         }  
  145.       else  
  146.         ret = view_getc_bwd(vf);  
  147.       }  
  148.       
  149.     if (!num_normal && ret == VIEW_EOF)
  150.       return(VIEW_EOF);
  151.     else
  152.       return(FALSE);
  153. }
  154. #endif /* VIEW_HAS_RAW */
  155.  
  156.  
  157. UINT view_getl_fwd( VIEWFILE *vf, UCHAR *line, int max )
  158. {
  159.     UINT ret;
  160.     int num_normal;
  161.     int new_idx,old_idx;
  162.  
  163. #if VIEW_HAS_RAW
  164.     if (vf->lmode)
  165.       return(view_getl_raw( vf, line, 1));
  166. #endif
  167.  
  168.     num_normal = 0;
  169.     new_idx    = 0;
  170.     old_idx    = 0;
  171.     ret = 0;
  172.  
  173.     while( (ret != VIEW_EOF) && (num_normal < max) )
  174.       {
  175.       ret = view_getc_fwd(vf);
  176.  
  177.       if (ret == '\n') 
  178.         break;
  179.       else if (ret == '\r')
  180.         continue;
  181.       else if (ret != VIEW_EOF)
  182.         {
  183.         num_normal ++;
  184.         if (new_idx < max) 
  185.           {
  186.           if (ret == TAB)
  187.             {
  188.             old_idx = new_idx;
  189.             new_idx = ((new_idx / 8)*8)+8;
  190.             while(old_idx < new_idx && old_idx < max)
  191.               line[old_idx++] = ' ';
  192.             new_idx = old_idx;
  193.             }
  194.           else if (ret == '\0')
  195.             line[new_idx++] = ' ';
  196.           else
  197.             line[new_idx++] = ret;
  198.           }
  199.         }
  200.       }
  201.  
  202.     line[new_idx] = '\0';
  203.  
  204.     if ((ret == VIEW_EOF) && !num_normal)
  205.       return(VIEW_EOF);
  206.     else
  207.       return(FALSE);
  208. }
  209.  
  210. UINT view_getl_bwd( VIEWFILE *vf, UCHAR *line, int max )
  211. {
  212.     UINT ret;
  213.     int num_newlines;
  214.     int num_normal;
  215.     int new_idx;
  216.  
  217. #if VIEW_HAS_RAW
  218.     if (vf->lmode)
  219.       return(view_getl_raw( vf, line, 0));
  220. #endif
  221.  
  222.     num_normal    = 0;
  223.     num_newlines  = 0;
  224.     ret  = 0;
  225.  
  226.     while ( (ret != VIEW_EOF)  && (num_newlines < 2) && (num_normal < max) )
  227.       {
  228.       ret = view_getc_bwd( vf );
  229.  
  230.       if ((ret == '\n') || ((num_newlines == 0) && (num_normal == 1)))
  231.         num_newlines ++;
  232.       else if (ret == '\r')
  233.         continue;
  234.       else if (ret != VIEW_EOF)
  235.         num_normal ++;
  236.       }
  237.  
  238.     if ((ret == VIEW_EOF) && !num_normal)
  239.       ret = VIEW_EOF;
  240.     else if (ret == '\n')
  241.       {
  242.       view_getc_fwd(vf);
  243.       ret = FALSE;
  244.       }
  245.     else
  246.       ret = FALSE;
  247.  
  248.     return(ret);
  249. }
  250.  
  251. VIEWFILE *view_open( UCHAR *fname )
  252. {
  253.   int th;
  254.   VIEWFILE *vf;
  255.  
  256.   vf = malloc(sizeof(VIEWFILE));
  257.   if (!vf) view_error(1,"VIEW0006");
  258.  
  259.   vf->pos = 0;
  260.   vf->idx = 0;
  261.   vf->len = 0;
  262.   vf->lmode = VIEW_TEXT_MODE;
  263.  
  264.  
  265.   if (fname)
  266.     {
  267.  
  268. #if VIEW_HAS_MEMORY
  269.  
  270.     if (!stricmp(fname,VIEW_MEM_NAME))
  271.       {
  272.       vf->fh = VIEW_MEM_HDL;
  273.       }
  274.     else
  275.  
  276. #endif
  277.     if ((vf->fh = open(fname,O_RDONLY|O_BINARY,S_IREAD|S_IWRITE)) < 0)
  278.       {
  279.       view_error(0,"Cannot Open File");
  280.       free(vf);
  281.       return(NULL);
  282.       }
  283.     }
  284.   else
  285.     {
  286.     if (!(th = open("CON",O_RDONLY,S_IREAD|S_IWRITE)))
  287.       view_error(1,"VIEW0007");
  288.  
  289.     fname     = "Standard Input";
  290.  
  291.     vf->fh    = dup(fileno(stdin));
  292.     setmode(vf->fh,O_BINARY);
  293.     dup2(th,fileno(stdin));
  294.     }
  295.  
  296.    if (vf->fh != VIEW_MEM_HDL)
  297.      {
  298.      vf->end = lseek(vf->fh,0L,SEEK_END);
  299.      vf->pos = lseek(vf->fh,0L,SEEK_SET);
  300.      vf->len = read(vf->fh,vf->buf,VIEW_BUF_SIZE);
  301.      vf->pos = lseek(vf->fh,0L,SEEK_SET);
  302.      }
  303.  
  304.    vf->fname = strdup(fname);
  305.    if (!vf->fname) view_error(1,"VIEW0008");
  306.  
  307.    return(vf);
  308. }
  309.  
  310. void view_close( VIEWFILE *vf )
  311. {
  312.    if (vf->fh != VIEW_MEM_HDL)
  313.      close(vf->fh);
  314.    free(vf->fname);
  315.    free(vf);
  316. }
  317.  
  318.  
  319. ULONG view_tell( VIEWFILE *vf )
  320. {
  321.   if (vf->fh == VIEW_MEM_HDL)
  322.     return(vf->pos);
  323.   else
  324.     return(vf->pos+vf->idx);
  325. }
  326.  
  327. ULONG view_seek( VIEWFILE *vf, long pos, int base )
  328. {
  329.   long tpos;
  330.   long rpos;
  331.   int  size;
  332.  
  333. #if VIEW_HAS_MEMORY
  334.   if (vf->fh == VIEW_MEM_HDL)
  335.     {
  336.     switch( base )
  337.       {
  338.       case SEEK_SET:
  339.       break;
  340.  
  341.       case SEEK_CUR:
  342.         pos = vf->pos + pos;
  343.       break;
  344.         
  345.       case SEEK_END:
  346.         pos = ULONG_MAX + pos;
  347.       break;
  348.       }
  349.  
  350.     vf->pos = pos;
  351.     return(pos);
  352.     }
  353.   else
  354.     {
  355. #endif
  356.     switch( base )
  357.       {
  358.       case SEEK_SET:
  359.         tpos = pos;
  360.       break;
  361.  
  362.       case SEEK_CUR:
  363.         tpos = (((long)vf->pos)+vf->idx)+pos;
  364.       break;
  365.  
  366.       case SEEK_END:
  367.         tpos = ((long)vf->end)+pos;
  368.       break;
  369.       }
  370.  
  371.     if (tpos < 0)       
  372.       {
  373.       vf->idx = 0;
  374.       return(0L);
  375.       }
  376.  
  377.     if (tpos > vf->end) 
  378.       {
  379.       vf->idx = vf->len;
  380.       return(vf->end);
  381.       }
  382.  
  383.     if (labs(tpos-vf->pos) > VIEW_BUF_SIZE)
  384.       {
  385.       vf->idx = 0;
  386.       vf->pos = lseek(vf->fh,tpos,SEEK_SET);
  387.       vf->len = read(vf->fh,vf->buf,VIEW_BUF_SIZE);
  388.       }
  389.     else if (tpos < vf->pos )
  390.       {
  391.       lseek(vf->fh,vf->pos,SEEK_SET);
  392.       size = (VIEW_BUF_SIZE/4);
  393.  
  394.       while ( tpos < vf->pos && size )
  395.         {
  396.         if (size > vf->pos) size = vf->pos;
  397.  
  398.         memmove(vf->buf+size,vf->buf,(VIEW_BUF_SIZE-size));
  399.  
  400.         vf->len += size;
  401.  
  402.         if (vf->len > VIEW_BUF_SIZE) 
  403.           vf->len = VIEW_BUF_SIZE;
  404.  
  405.         lseek(vf->fh,((long)(-size)),SEEK_CUR);
  406.  
  407.         read(vf->fh,vf->buf,size);
  408.  
  409.         vf->pos = lseek(vf->fh,((long)(-size)),SEEK_CUR);
  410.  
  411.         vf->idx = (tpos - vf->pos);
  412.         }
  413.       }
  414.     else if (tpos >= (vf->pos+vf->len))
  415.       {
  416.       rpos = vf->pos + vf->len;
  417.  
  418.       lseek(vf->fh,rpos,SEEK_SET);
  419.       size = (VIEW_BUF_SIZE/4);
  420.  
  421.       while ( tpos >= rpos && size )
  422.         {
  423.         if (size > (vf->end-rpos))
  424.           size = (vf->end-rpos);
  425.  
  426.         if (vf->len > (VIEW_BUF_SIZE-size))
  427.           {
  428.           memmove(vf->buf,vf->buf+size,(VIEW_BUF_SIZE-size));
  429.           vf->len -= size;
  430.           if (vf->len < 0) vf->len = 0;
  431.           }
  432.  
  433.         read(vf->fh,vf->buf+vf->len,size);
  434.  
  435.         vf->len += size;
  436.         rpos    += size;
  437.         vf->pos += size;
  438.  
  439.         vf->idx = (tpos - vf->pos);
  440.         }
  441.       }
  442.     else
  443.       vf->idx = (tpos - vf->pos);
  444. #if VIEW_HAS_MEMORY
  445.     }
  446. #endif
  447. }
  448.